{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9d3716bb",
   "metadata": {},
   "source": [
    "# 模拟一维海森堡链的自旋动力学\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0832e9f",
   "metadata": {},
   "source": [
    "## 概述\n",
    "\n",
    "模拟一个量子系统的性质，是量子计算机的重要应用之一。一般来说，分析一个量子系统的性质需要先写出其哈密顿量 $H$，而对于不同尺度下的物理系统而言，这个哈密顿量往往具有不同的形式。以量子化学为例，一个分子的性质主要由电子-电子之间的库伦相互作用而决定，因此其哈密顿量中的每一项都是由作用在电子波函数上的费米子算符写成的。而量子计算机的基本组成单元量子比特（qubit）以及常用的泡利算符，对应着物理上的自旋和自旋算符。因此，若想在量子计算机上对分子性质进行模拟，则往往需要进行从费米子算符到泡利算符的转换，例如 Jordan-Wigner 变换、Bravyi-Kitaev 变换等等。这也就使得量子计算机需要消耗更多的资源来进行分子哈密顿量的模拟。因此，对于近期的量子设备而言，最有可能率先实现的便是对量子自旋系统的量子模拟——因为这些系统的哈密顿量可以直接写成泡利算符的形式。\n",
    "\n",
    "在本教程中，我们选取了一个比较经典的量子自旋模型——海森堡模型，并将展示如何利用 Paddle Quantum 来进行一维海森堡自旋链的时间演化模拟。我们主要会使用 `construct_trotter_circuit()` 函数来搭建基于 product formula 的模拟时间演化电路，在先前的教程 [利用 Product Formula 模拟时间演化](./HamiltonianSimulation_CN.ipynb) 中有对该方法较为详细的理论介绍，在本教程中也会有较为简略的回顾。本教程将主要着眼于实际的应用，可以分为两个部分：\n",
    "- 海森堡模型的物理背景以及利用 Paddle Quantum 对其时间演化进行模拟 \n",
    "- 基于随机置换来搭建自定义时间演化电路"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "988b3a47",
   "metadata": {},
   "source": [
    "---\n",
    "在进一步介绍本教程中涉及的物理背景之前，我们先来回顾一下利用量子电路来模拟时间演化的基本思想，对这部分内容已经比较熟悉的读者可以直接跳至 **海森堡自旋链与其动力学模拟** 继续阅读。\n",
    "\n",
    "### 利用 Suzuki product formula 模拟时间演化\n",
    "\n",
    "让我们先回顾一下使用 Suzuki product formula 来模拟时间演化的基本思想：对于一个被不含时的哈密顿量 $H = \\sum_k^L h_k$ 描述的量子系统，其时间演化算符可以写为\n",
    "\n",
    "$$\n",
    "U(t) = e^{-iHt},\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "该算符可以被进一步拆分为 $r$ 份，即\n",
    "\n",
    "$$\n",
    "e^{-iHt} = \\left( e^{-iH \\tau} \\right)^r, ~\\tau=\\frac{t}{r}.\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "对于每一个 $e^{-iH \\tau}$ 算符而言，其 Suzuki 分解为\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau),\n",
    "\\\\\n",
    "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2}),\n",
    "\\\\\n",
    "S_{2k+2}(\\tau) &= [S_{2k}(p_k\\tau)]^2S_{2k}\\left( (1-4p_k)\\tau\\right)[S_{2k}(p_k\\tau)]^2.\n",
    "\\end{aligned}\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "回到完整的时间演化算符 $U(t)$，利用第 $k$ 阶的 Suzuki 分解，它可以被写为\n",
    "\n",
    "$$\n",
    "U(t) = e^{-iHt} = \\left( S_{k}\\left(\\frac{t}{r}\\right) \\right)^r.\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "这种模拟时间演化的方法被称为 Suzuki product formula，它可以有效地模拟时间演化过程至任意精度 [1]。在另一份教程 [利用 Product Formula 模拟时间演化](./HamiltonianSimulation_CN.ipynb) 中，我们展示了其误差上界的计算过程，感兴趣的读者可以前往阅读。\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab3f7311",
   "metadata": {},
   "source": [
    "## 海森堡模型与其动力学模拟\n",
    "\n",
    "海森堡（Heisenberg）模型，是量子磁性以及量子多体物理研究中十分重要的一个模型。它的哈密顿量为\n",
    "\n",
    "$$\n",
    "H = \\sum_{\\langle i, j\\rangle} \n",
    "\\left( J_x S^x_{i} S^x_{j} + J_y S^y_{i} S^y_{j} + J_z S^z_{i} S^z_{j} \\right)\n",
    "+\n",
    "\\sum_{i} h_z S^z_i, \n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "其中 $\\langle i, j\\rangle$ 取决于具体的格点几何结构，$J_x, J_y, J_z$ 分别为 $xyz$ 三个方向上的自旋耦合强度，$h_z$ 是 $z$ 方向上的外加磁场。若取 $J_z = 0$，(5) 式也可以用来描述 XY 模型的哈密顿量；取 $J_x = J_y = 0$，(5) 式则可以用来描述伊辛模型（Ising model）的哈密顿量。注意在这里，我们使用了量子多体物理里面比较常用的多体自旋算符 $S^x_i, S^y_i, S^z_i$，它是一个作用在多体波函数上的算符。\n",
    "对于自旋-1/2 系统而言，多体自旋算符可以被简单地写为泡利算符的张量积形式（省略一个 $\\hbar/2$ 的系数）\n",
    "\n",
    "$$\n",
    "S^P_{i} = \\left ( \\otimes_{j=0}^{i-1} I \\right ) \\otimes \\sigma_{P} \\otimes \\left ( \\otimes_{j=i+1}^{L} I \\right ),\n",
    "P \\in \\{ x, y, z \\},\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "其中 $\\sigma_{P}$ 是泡利算符，我们也经常用 $XYZ$ 算符来表示它们。需要说明的是，海森堡模型并不是一个假想模型：从描述电子在格点系统上运动的赫巴德模型（Hubbard model）出发，在一定的极限条件下，电子会被固定在格点上并形成半满填充。此时，描述电子的赫巴德模型就退化为了描述自旋的海森堡模型，而 (5) 式中的自旋-自旋相互作用则是电子-电子之间的相互作用在这个极限下的一种有效交换相互作用 [2]。尽管做了许多的近似，但是海森堡模型依然成功地预言了许多实际材料在低温下的性质 [3]。比如读者可能在高中课本上就学习过的 $\\rm Cu(NO_3)_2 \\cdot 2.5 H_2 O$ 二点五水合硝酸铜在 $\\sim 3K$ 的低温下的行为就可以被自旋-1/2 一维交错海森堡链所描述 [4]。\n",
    "\n",
    "取决于其具体的格点结构，海森堡模型上可以展示出丰富的量子现象。一维海森堡链可以被用来描述铁磁性与反铁磁性，对称性破缺以及无能隙激发。在二维阻挫格点系统上，海森堡模型可以被用来描述量子自旋液体态-这是一种包含了长程纠缠的新奇量子物态 [5]。若考虑一个外加的无序磁场时，海森堡模型还可以用来研究多体局域化现象（many-body localization, MBL），这是一种违反了热化假说的奇特现象，指的是一个量子多体系统经过了无穷长的时间演化后也不会热化，依然保留着其初态有关的信息 [6]。\n",
    "\n",
    "模拟海森堡模型的时间演化过程，也被称为动力学模拟，可以帮助人们探索量子系统非平衡态相关的性质，从而用来寻找新奇的量子物相：例如前文提到的多体局域相，又或者更加有趣的时间晶体相 [7]。除了理论，动力学模拟对于实际的物理实验也有着重要的意义。这是因为自旋关联函数（也通常被称为动力学结构因子）直接决定了散射实验中的截面，或者是核磁共振实验的结果 [3]，该函数则是由含时的自旋算符 $\\langle S(t) S(0) \\rangle$ 的积分决定的。因此，通过计算不同理论模型的动力学演化，人们可以进一步对真实材料中的物理模型进行分析。\n",
    "\n",
    "### 利用 Paddle Quantum 实现海森堡链的动力学模拟"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aea361f7",
   "metadata": {},
   "source": [
    "下面，我们则会通过一个实际的例子：链长为 5 的含有无序外磁场的海森堡链，来展示如何在 Paddle Quantum 中搭建其时间演化电路。首先，我们引入相关的包。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5c873819",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy\n",
    "from scipy import linalg\n",
    "import matplotlib.pyplot as plt\n",
    "from paddle_quantum.circuit import UAnsatz\n",
    "from paddle_quantum.utils import SpinOps, Hamiltonian, gate_fidelity\n",
    "from paddle_quantum.trotter import construct_trotter_circuit, get_1d_heisenberg_hamiltonian"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c81929b",
   "metadata": {},
   "source": [
    "接下来，我们利用 `get_1d_heisenberg_hamiltonian()` 函数来得到一个一维海森堡链的哈密顿量： "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "88fa56fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "系统的哈密顿量为：\n",
      "1.0 X0, X1\n",
      "1.0 Y0, Y1\n",
      "2.0 Z0, Z1\n",
      "1.0 X1, X2\n",
      "1.0 Y1, Y2\n",
      "2.0 Z1, Z2\n",
      "1.0 X2, X3\n",
      "1.0 Y2, Y3\n",
      "2.0 Z2, Z3\n",
      "1.0 X3, X4\n",
      "1.0 Y3, Y4\n",
      "2.0 Z3, Z4\n",
      "-0.8540490813629811 Z0\n",
      "-0.017499184685274338 Z1\n",
      "0.08600328703303406 Z2\n",
      "0.9440767245343289 Z3\n",
      "-0.9640203537370211 Z4\n"
     ]
    }
   ],
   "source": [
    "h = get_1d_heisenberg_hamiltonian(length=5, j_x=1, j_y=1, j_z=2, h_z=2 * np.random.rand(5) - 1,\n",
    "periodic_boundary_condition=False)\n",
    "print('系统的哈密顿量为：')\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0793414b",
   "metadata": {},
   "source": [
    "得到了哈密顿量之后，可以进一步通过 `construct_trotter_circuit()` 来构建时间演化电路。此外，若直接写出演化算符的矩阵形式，也可以计算系统随时间演化的精确解。这里我们用到了量桨中的 `Hamiltonian.construct_h_matrix()` 方法，它可以计算给定哈密顿量在泡利 $Z$ 基底下的矩阵形式。通过比较 `cir.U`，即电路的酉矩阵形式，以及精确的演化算符，可以计算出该电路模拟时间演化的保真度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5052fb32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "电路的酉矩阵与正确的演化算符之间的保真度为：0.55\n"
     ]
    }
   ],
   "source": [
    "# 计算演化时长为 t 时的精确演化算符\n",
    "def get_evolve_op(t): return scipy.linalg.expm(-1j * t * h.construct_h_matrix())\n",
    "\n",
    "# 设置演化时长以及模拟的步长\n",
    "t = 3\n",
    "r = 10\n",
    "# 搭建模拟演化电路\n",
    "cir_evolve = UAnsatz(5)\n",
    "construct_trotter_circuit(cir_evolve, h, tau=t/r, steps=r, order=2)\n",
    "# 得到电路的酉矩阵并计算与精确演化算符之间的保真度\n",
    "U_cir = cir_evolve.U.numpy()\n",
    "print('电路的酉矩阵与正确的演化算符之间的保真度为：%.2f' % gate_fidelity(get_evolve_op(t), U_cir))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce487d74",
   "metadata": {},
   "source": [
    "#### 根据对易关系重新排列哈密顿量\n",
    "\n",
    "对于 product formula 而言，可以通过重新排列哈密顿量中的每一项减小其模拟误差。因为 product formula 的误差是由哈密顿量中不对易项所产生的，所以一种自然的重新排列思路就是将哈密顿量中相互对易的项放在一起。比如，我们可以将哈密顿量分解为四个部分\n",
    "\n",
    "$$\n",
    "H = H_x + H_y + H_z + H_{\\rm other},\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "其中 $H_x, H_y, H_z$ 分别为仅由泡利 $X, Y, Z$ 算符构成的项，$H_{\\rm other}$ 为剩余项。对于 (5) 中的海森堡链的哈密顿量而言，所有的项都可以被分类为 $H_x, H_y, H_z$ 三项。不仅如此，对于一维最近邻相互作用系统而言，它也可以被分为奇偶两个部分\n",
    "\n",
    "$$\n",
    "H = H_{\\rm even} + H_{\\rm odd},\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "其中 $H_{\\rm even}$ 为 $(0, 1), (2, 3), ...$ 格点上的相互作用项，$H_{\\rm odd}$ 为 $(1, 2), (3, 4), ...$ 格点上的相互作用项。 不过需要指出的是，这两种排列方式都不能减少其理论上的误差上界。并且从经验的角度来说，它们也不是总能减小实际的模拟误差。实际上，确定对于某一类哈密顿量而言模拟误差的排列方式，是一个十分值得探索的问题。对于量桨中的 `construct_h_matrix()` 函数而言，用户可以通过指定 `grouping='xyz'` 或者 `grouping='even_odd'` 来实现上文中提到的两种重新排列方式，此外，通过传入参数 `permutation` 也可以指定自定义排列顺序。关于后一点，本教程将在下文章节 **设计基于随机置换的自定义时间演化电路** 中进一步介绍。下面，先让我们来看一下关于 `grouping` 参数的使用方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b2eaca4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "原始保真度为： 0.5515968012823682\n",
      "XYZ 排列后的模拟保真度为： 0.703033891885116\n",
      "奇偶排列后的模拟保真度为： 0.744121841784116\n"
     ]
    }
   ],
   "source": [
    "# 保持同样的时间演化参数，但是在通过 'grouping=\"xyz\"' 和 'groping=\"even_odd\"' 指定哈密顿量排列\n",
    "cir_evolve_xyz = UAnsatz(5)\n",
    "cir_evolve_even_odd = UAnsatz(5)\n",
    "construct_trotter_circuit(cir_evolve_xyz, h, tau=t/r, steps=r, order=2, grouping='xyz')\n",
    "construct_trotter_circuit(cir_evolve_even_odd, h, tau=t/r, steps=r, order=2, grouping='even_odd')\n",
    "U_cir_xyz = cir_evolve_xyz.U.numpy()\n",
    "U_cir_even_odd = cir_evolve_even_odd.U.numpy()\n",
    "print('原始保真度为：', gate_fidelity(get_evolve_op(t), U_cir))\n",
    "print('XYZ 排列后的模拟保真度为：', gate_fidelity(get_evolve_op(t), U_cir_xyz))\n",
    "print('奇偶排列后的模拟保真度为：', gate_fidelity(get_evolve_op(t), U_cir_even_odd))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f18e3f16",
   "metadata": {},
   "source": [
    "#### 初态制备以及对演化后的末态进行观测\n",
    "\n",
    "下面，我们来制备系统的初态。一般来说，在研究量子多体系统的动力学行为时，一种做法是将系统的初态制备为各种不同的直积态。在量桨中，我们默认的初态为 $\\vert 0...0 \\rangle$，这里我们可以通过 $X$ 门来将奇数格点上的自旋进行翻转，这样系统的初态就制备为了 $\\vert 01010 \\rangle$ 态，用自旋来标记的话则是 $\\vert \\downarrow \\uparrow \\downarrow \\uparrow \\downarrow \\rangle$ 态。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e0ff6736",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建一个用于制备初态的电路，并通过演化得到初态\n",
    "cir = UAnsatz(5)\n",
    "cir.x(1)\n",
    "cir.x(3)\n",
    "init_state = cir.run_state_vector()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffa62418",
   "metadata": {},
   "source": [
    "通过将系统的初态 `init_state` 传入方法 `UAnsatz.run_state_vector(init_state)`，我们可以利用刚刚定义的量子线路来演化该初态，并得到演化后的末态。对于演化后的末态，可以使用 `UAnsatz.expecval()` 方法来测量其上的可观测量。这里我们简单地考虑对每个格点上的自旋状态进行观测，即测量可观测量 $\\langle S^z_i \\rangle$，其对应的 Pauli string 为 `[[1, 'Zi']]`（i 为格点下标）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "88d5e1b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "演化后格点 0 上自旋的 z 方向期望为： 0.9206501927076486\n"
     ]
    }
   ],
   "source": [
    "cir_evolve_even_odd.run_state_vector(init_state)\n",
    "print('演化后格点 0 上自旋的 z 方向期望为：', cir_evolve_even_odd.expecval([[1, 'Z0']]).numpy()[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e70d9fba",
   "metadata": {},
   "source": [
    "类似地，通过调整模拟演化的时间长度以及测量的量子比特编号，我们可以绘制出系统中的每个自旋的状态随着时间的完整变化过程。注意这里为了计算理论上的精确解，我们使用了 `SpinOps` 类来构建 $S_i^z$ 算符的矩阵形式，并通过 $\\langle \\psi(t) \\vert S_i^z \\vert \\psi(t) \\rangle$ 来计算其期望值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6c4c03ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_evolution_z_obs(h, t_total, order=None, n_steps=None, exact=None):\n",
    "    \"\"\"\n",
    "    该函数可以计算演化过程 t 中系统每个格点上的 Sz 可观测量的变化过程\n",
    "    通过 order, n_steps 控制 trotter-suzuki 分解的步长和阶数\n",
    "    通过设置 exact=True 可以计算对应的精确解\n",
    "    \"\"\"\n",
    "    z_obs_total = []\n",
    "    for t in np.linspace(0., t_total, t_total * 3 + 1):\n",
    "        z_obs = []\n",
    "        # 通过演化算符或者运行电路得到末态\n",
    "        if exact:\n",
    "            spin_operators = SpinOps(h.n_qubits)\n",
    "            fin_state = get_evolve_op(t).dot(init_state)\n",
    "        else:\n",
    "            cir_evolve = UAnsatz(5)\n",
    "            construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=order, grouping='even_odd')\n",
    "            fin_state = cir_evolve.run_state_vector(init_state)\n",
    "        # 对每个格点上的可观测量进行观测\n",
    "        for site in range(h.n_qubits):\n",
    "            if exact:\n",
    "                z_obs.append(fin_state.conj().T.dot(spin_operators.sigz_p[site]).dot(fin_state))\n",
    "            else:\n",
    "                z_obs.append(cir_evolve.expecval([[1, 'Z' + str(site)]]).numpy()[0])\n",
    "        z_obs_total.append(z_obs)\n",
    "    return np.array(z_obs_total).real  \n",
    "\n",
    "def plot_comparison(**z_obs_to_plot):\n",
    "    \"\"\" \n",
    "    绘制不同的演化结果进行对比，默认每个传入的参数都是 get_evolution_z_obs() 函数的输出并具有同样的演化时间\n",
    "    \"\"\"\n",
    "    fig, axes = plt.subplots(1, len(z_obs_to_plot), figsize = [len(z_obs_to_plot) * 3, 5.5])\n",
    "    \n",
    "    ax_idx = 0\n",
    "    for label in z_obs_to_plot.keys():\n",
    "        im = axes[ax_idx].imshow(z_obs_to_plot[label], cmap='coolwarm_r', interpolation='kaiser', origin='lower')\n",
    "        axes[ax_idx].set_title(label, fontsize=15)\n",
    "        ax_idx += 1\n",
    "\n",
    "    for ax in axes:\n",
    "        ax.set_xlabel('site', fontsize=15)\n",
    "        ax.set_yticks(np.arange(0, z_obs_total_exact.shape[0], 3))\n",
    "        ax.set_yticklabels(np.arange(0, z_obs_total_exact.shape[0]/3, 1))\n",
    "        ax.set_xticks(np.arange(z_obs_total_exact.shape[1]))\n",
    "        ax.set_xticklabels(np.arange(z_obs_total_exact.shape[1]))\n",
    "\n",
    "    axes[0].set_ylabel('t', fontsize=15)\n",
    "    cax = fig.add_axes([0.92, 0.125, 0.02, 0.755])\n",
    "    \n",
    "    \n",
    "    fig.colorbar(im, cax)\n",
    "    cax.set_ylabel(r'$\\langle S^z_i (t) \\rangle$', fontsize=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3735e79a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x396 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 分别计算时长为 3 时，通过步长为 25、5 的电路得到的演化过程，以及精确解\n",
    "z_obs_total_exact = get_evolution_z_obs(h, t_total=3, exact=True)\n",
    "z_obs_total_cir = get_evolution_z_obs(h, order=1, n_steps=25, t_total=3)\n",
    "z_obs_total_cir_short = get_evolution_z_obs(h, order=1, n_steps=5, t_total=3)\n",
    "\n",
    "plot_comparison(\n",
    "    Exact=z_obs_total_exact,\n",
    "    L25_Circuit=z_obs_total_cir,\n",
    "    L5_Circuit=z_obs_total_cir_short)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "707ecfdf",
   "metadata": {},
   "source": [
    "我们观察到当线路的深度为 25 时（注意这里的深度指的是时间块的数量而不是量子门的层数），量子电路可以较好的模拟系统在完整演化时间内的自旋动力学。若使用较浅的量子线路，则只能正确模拟系统的行为至一定的时间。\n",
    "\n",
    "**思考：** 读者是否可以尝试来测量自旋空间关联函数 $\\langle S_i^z S_j^{z} \\rangle$ 并观察其随时间的变化？"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af97d494",
   "metadata": {},
   "source": [
    "## 设计基于随机置换的自定义时间演化电路\n",
    "\n",
    "### 随机置换\n",
    "\n",
    "尽管从物理的角度上看来，将哈密顿量中的对易项重新排列在一起来减小模拟误差是符合直觉的，但是许多证据都表明，固定一种哈密顿量排列的演化策略将会导致模拟误差不断地累积，反而不如将哈密顿量的排列顺序在每个“时间块”中都进行随机置换来得有效 [8, 9]。人们发现，通过不断地将哈密顿量的排列顺序进行随机置换，其演化过程中造成的随机误差比起固定排列时的累积误差来说更加“无害” [8]。无论是在理论上的误差上界与经验性的实验都表明，这种随机排列的演化策略比起固定排列的 Suzuki product formula 具有更小的误差 [9]。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63f289c5",
   "metadata": {},
   "source": [
    "### 搭建自定义时间演化电路\n",
    "\n",
    "量桨中的 `construct_trotter_circuit()` 函数会默认根据 Suzuki product formula 以及输入哈密顿量的顺序来添加时间演化电路。同时，用户可以通过设置 `method='custom'` 并同时向参数 `permutation` 以及 `coefficient` 传入数组的方式来自定义时间演化策略。\n",
    "\n",
    "**提醒：** 用户在使用 `coefficient`、`tau` 以及 `steps` 参数时需要小心它们之间的关系。一般情况下，传入 `coefficient` 的数组应当是归一化的，即它本身描述的是 $t=1$ 的时间演化过程。在这个基础上，通过设置更多的 `steps`，该函数会将传入的自定义参数所描述的时间演化策略作为一个基本的“时间块”并进行重复，其中每个时间块的演化时长由参数 `tau` 决定。举个例子，若设置 `permutation=np.arange(h.n_qubits)` 且 `coefficient=np.ones(h.n_qubits)`，此时通过 `tau` 与 `steps` 来定义的时间演化电路与一阶 product formula 电路是完全一致的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e72345ac",
   "metadata": {},
   "source": [
    "让我们进一步实际展示一下该自定义功能：考虑和之前相同的哈密顿量，现在我们通过设计一个时间演化电路来测试上文提到的随机置换的结论，即我们希望搭建一个类似于一阶 product formula 的电路，只不过在每个”时间块“内的哈密顿量排列是完全随机且独立的。通过传入一个形状为 `(n_steps, h.n_terms)` 且其每一行都是一个随机置换 $P(N)$ 的数组至参数 `permutation`，就可以实现这一想法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1740ec7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 自定义 permutation 参数的一个例子\n",
    "permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(100)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23a1eb6d",
   "metadata": {},
   "source": [
    "接下来，为了验证，可以分别计算该随机电路以及一阶 product formula 在不同电路深度下与精确解之间的保真度来进行比较："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "73084cfc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def compare(n_steps):\n",
    "    \"\"\"\n",
    "    比较一阶 product formula 以及随机置换方法在同样的步长的情况下对于固定演化时长 t=2 时的保真度\n",
    "    输入参数控制步长，输出分别为一阶 product formula 以及随机置换的保真度\n",
    "    \"\"\"\n",
    "    t = 2\n",
    "    cir_evolve = UAnsatz(5)\n",
    "    construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=1)\n",
    "    U_cir = cir_evolve.U.numpy()\n",
    "    fid_suzuki = gate_fidelity(get_evolve_op(t), U_cir)\n",
    "    cir_permute = UAnsatz(5)\n",
    "    permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(n_steps)])\n",
    "    # 当不指定 coefficient 参数时，会默认根据 permutation 的形状设置一个归一化且均匀的 coefficient\n",
    "    construct_trotter_circuit(cir_permute, h, tau=t, steps=1, method='custom', permutation=permutation)\n",
    "    U_cir = cir_permute.U.numpy()\n",
    "    fid_random = gate_fidelity(get_evolve_op(t), U_cir)\n",
    "    return fid_suzuki, fid_random\n",
    "\n",
    "# 比较在不同步长时的两种方案的保真度\n",
    "# 出于运行时间的考虑，只进行一次试验，感兴趣的读者可以进行多次重复实验并计算其 error bar\n",
    "n_range = [100, 200, 500, 1000]\n",
    "result = [compare(n) for n in n_range]\n",
    "\n",
    "result = 1 - np.array(result)\n",
    "plt.loglog(n_range, result[:, 0], 'o-', label='1st order PF')\n",
    "plt.loglog(n_range, result[:, 1], 'o-', label='Random')\n",
    "plt.xlabel(r'Trotter number $r$', fontsize=12)\n",
    "plt.ylabel(r'Error: $1 - {\\rm Fid}$', fontsize=12)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85f72361",
   "metadata": {},
   "source": [
    "图中，“1st order PF” 指按照固定顺序搭建的一阶 product formula 电路。与预期一样，随机置换确实可以在相同的电路深度下达到比一阶 product formula 更好的模拟效果。\n",
    "\n",
    "**思考：** 在 [9] 中，作者指出这种随机的策略在没有利用任何与哈密顿量有关的信息的前提下就取得了更小的误差，那么有理由相信存在一种方法可以在利用哈密顿量信息的同时进一步减小该误差。这对于人们设计更好的模拟时间演化策略带来了启发。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f193c11",
   "metadata": {},
   "source": [
    "## 小结\n",
    "\n",
    "对于量子多体系统的动力学性质进行研究，是理解新奇量子物态的重要手段。由于其高度纠缠的量子力学本质，无论是在理论上还是在实验上的研究都是十分困难的。时至今日，人们对于不同几何结构，不同相互作用下的二维，乃至包含了无序性的一维系统上的物理现象都没能完全理解。另一方面，通用量子计算机以及量子模拟器的快速发展给这一问题的解决带来了新的希望。以通用量子计算机为例，通过搭建量子电路，其优势在于可以模拟各种复杂情况下的系统演化过程，例如，模拟其哈密顿量随时间周期性变化的系统从而寻找“时间晶体”的存在。随着量子比特数目和控制能力的进一步提高，通用量子计算机有望在近未来内在模拟量子系统时间演化这一任务上超越经典计算机，这其中，最有希望最先取得进展的就是量子自旋系统的模拟。\n",
    "\n",
    "本教程主要介绍了如何在量桨中模拟一个真实量子自旋模型的时间演化过程，并且进一步探讨了基于量桨来设计新的时间演化策略的可能性。通过 `construct_trotter_circuit()` 函数以及 `Hamiltonian` 和 `SpinOps` 类中提供的各种方法，用户现在可以简单地设计并测试不同搭建时间演化的策略。我们也鼓励读者在更多的物理系统上尝试不同的时间演化策略，并一起探索更加高效的量子模拟电路。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff5b39fa",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## 参考文献\n",
    "\n",
    "[1] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n",
    "\n",
    "[2] Eckle, Hans-Peter. Models of Quantum Matter: A First Course on Integrability and the Bethe Ansatz. [Oxford University Press, 2019](https://oxford.universitypressscholarship.com/view/10.1093/oso/9780199678839.001.0001/oso-9780199678839).\n",
    "\n",
    "[3] Mikeska, Hans-Jürgen, and Alexei K. Kolezhuk. \"One-dimensional magnetism.\" Quantum magnetism. Springer, Berlin, Heidelberg, 2004. 1-83.\n",
    "\n",
    "[4] Berger, L., S. A. Friedberg, and J. T. Schriempf. \"Magnetic Susceptibility of $\\rm Cu(NO_3)_2·2.5 H_2O$ at Low Temperature.\" [Physical Review 132.3 (1963): 1057](https://journals.aps.org/pr/abstract/10.1103/PhysRev.132.1057).\n",
    "\n",
    "[5] Broholm, C., et al. \"Quantum spin liquids.\" [Science 367.6475 (2020)](https://science.sciencemag.org/content/367/6475/eaay0668).\n",
    "\n",
    "[6] Abanin, Dmitry A., et al. \"Colloquium: Many-body localization, thermalization, and entanglement.\" [Reviews of Modern Physics 91.2 (2019): 021001](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.91.021001).\n",
    "\n",
    "[7] Medenjak, Marko, Berislav Buča, and Dieter Jaksch. \"Isolated Heisenberg magnet as a quantum time crystal.\" [Physical Review B 102.4 (2020): 041117](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.102.041117).\n",
    "\n",
    "[8] Wallman, Joel J., and Joseph Emerson. \"Noise tailoring for scalable quantum computation via randomized compiling.\" [Physical Review A 94.5 (2016): 052325](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.94.052325).\n",
    "\n",
    "[9] Childs, Andrew M., Aaron Ostrander, and Yuan Su. \"Faster quantum simulation by randomization.\" [Quantum 3 (2019): 182](https://quantum-journal.org/papers/q-2019-09-02-182/)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
